import { BaseStorageService, PROJECT_CONFIG, StorageConfig } from './storage/baseStorageService';

// 公募基金投资计划数据接口（重新定义，明确基金特有字段）
export interface SavedFundInvestPlan {
  id: string;
  fundCode: string;
  fundName: string;
  currentPrice: number;           // 当前净值
  maxDrawdown: number;           // 历史最大回撤
  totalAmount: number;           // 总投资金额（按金额购买）
  buyTimes: number;              // 计划买入次数
  strategy: string;              // 投资策略
  averagePrice: number;          // 预期平均成本
  riskLevel: string;             // 风险等级
  maxLoss: number;               // 最大可能亏损
  expectedShares: number;        // 预期份额（计算得出）
  
  // 公募基金特有字段
  fundType: '股票型' | '债券型' | '混合型' | '货币型' | '指数型' | 'QDII'; // 基金类型
  fundCompany: string;           // 基金公司
  managementFee: number;         // 管理费率
  custodyFee: number;            // 托管费率
  subscriptionFee: number;       // 申购费率
  redemptionFee: number;         // 赎回费率
  minInvestAmount: number;       // 最小投资金额
  
  createdAt: string;
  updatedAt: string;
}

// 公募基金投资计划服务类 - 继承基础存储服务
class FundInvestPlanService extends BaseStorageService<SavedFundInvestPlan> {
  constructor(config: StorageConfig = { type: 'indexedDB' }) {
    // 使用项目统一配置中定义的基金投资计划存储名称
    super(PROJECT_CONFIG.STORE_NAMES.FUND_PLANS, config);
  }

  // 业务特定的方法 - 保存基金投资计划
  async saveFundInvestPlan(plan: SavedFundInvestPlan): Promise<void> {
    // 验证用户登录状态
    const { isUserAuthenticated } = await import('../utils/userContext');
    if (!(await isUserAuthenticated())) {
      throw new Error('用户未登录，无法保存基金投资计划');
    }
    
    // 验证基金特有的业务规则
    this.validateFundPlan(plan);
    return this.save(plan);
  }

  // 业务特定的方法 - 获取所有基金投资计划
  async getFundInvestPlans(): Promise<SavedFundInvestPlan[]> {
    return this.getAll();
  }

  // 业务特定的方法 - 根据ID获取基金投资计划
  async getFundInvestPlanById(id: string): Promise<SavedFundInvestPlan | null> {
    return this.getById(id);
  }

  // 业务特定的方法 - 删除基金投资计划
  async deleteFundInvestPlan(id: string): Promise<void> {
    return this.delete(id);
  }

  // 业务特定的方法 - 批量删除基金投资计划
  async deleteFundInvestPlans(ids: string[]): Promise<void> {
    return this.deleteMany(ids);
  }

  // 业务特定的方法 - 导出所有基金投资计划
  async exportAllPlans(): Promise<string> {
    return this.exportAll();
  }

  // 业务特定的方法 - 导入基金投资计划
  async importPlans(jsonData: string): Promise<void> {
    try {
      const plans: SavedFundInvestPlan[] = JSON.parse(jsonData);
      
      // 业务特定的数据验证
      for (const plan of plans) {
        if (!plan.fundCode || !plan.fundName) {
          throw new Error('导入数据格式错误：缺少基金代码或基金名称');
        }
      }
      
      return this.import(jsonData);
    } catch (error) {
      throw new Error(`导入基金投资计划失败: ${error}`);
    }
  }

  // 业务特定的方法 - 根据基金代码查询
  async getFundInvestPlansByCode(fundCode: string): Promise<SavedFundInvestPlan[]> {
    const allPlans = await this.getFundInvestPlans();
    return allPlans.filter(plan => plan.fundCode === fundCode);
  }

  // 业务特定的方法 - 根据基金类型查询
  async getFundInvestPlansByType(fundType: SavedFundInvestPlan['fundType']): Promise<SavedFundInvestPlan[]> {
    const allPlans = await this.getFundInvestPlans();
    return allPlans.filter(plan => plan.fundType === fundType);
  }

  // 业务特定的方法 - 根据基金公司查询
  async getFundInvestPlansByCompany(fundCompany: string): Promise<SavedFundInvestPlan[]> {
    const allPlans = await this.getFundInvestPlans();
    return allPlans.filter(plan => plan.fundCompany === fundCompany);
  }

  // 业务特定的方法 - 根据风险等级查询
  async getFundInvestPlansByRiskLevel(riskLevel: string): Promise<SavedFundInvestPlan[]> {
    const allPlans = await this.getFundInvestPlans();
    return allPlans.filter(plan => plan.riskLevel === riskLevel);
  }

  // 业务特定的方法 - 获取基金投资统计信息
  async getFundInvestmentStatistics(): Promise<{
    totalPlans: number;
    totalInvestment: number;
    totalExpectedShares: number;
    averageAmount: number;
    typeDistribution: Record<string, number>;
    companyDistribution: Record<string, number>;
    riskDistribution: Record<string, number>;
    averageManagementFee: number;
  }> {
    const plans = await this.getFundInvestPlans();
    
    return {
      totalPlans: plans.length,
      totalInvestment: plans.reduce((sum, plan) => sum + plan.totalAmount, 0),
      totalExpectedShares: plans.reduce((sum, plan) => sum + plan.expectedShares, 0),
      averageAmount: plans.length > 0 ? plans.reduce((sum, plan) => sum + plan.totalAmount, 0) / plans.length : 0,
      typeDistribution: plans.reduce((acc, plan) => {
        acc[plan.fundType] = (acc[plan.fundType] || 0) + 1;
        return acc;
      }, {} as Record<string, number>),
      companyDistribution: plans.reduce((acc, plan) => {
        acc[plan.fundCompany] = (acc[plan.fundCompany] || 0) + 1;
        return acc;
      }, {} as Record<string, number>),
      riskDistribution: plans.reduce((acc, plan) => {
        acc[plan.riskLevel] = (acc[plan.riskLevel] || 0) + 1;
        return acc;
      }, {} as Record<string, number>),
      averageManagementFee: plans.length > 0 ? plans.reduce((sum, plan) => sum + plan.managementFee, 0) / plans.length : 0
    };
  }

  // 验证基金投资计划的业务规则
  private validateFundPlan(plan: SavedFundInvestPlan): void {
    // 验证最小投资金额
    if (plan.totalAmount < plan.minInvestAmount) {
      throw new Error(`投资金额不能少于最小投资金额：${plan.minInvestAmount}元`);
    }

    // 验证基金代码格式（简单验证）
    if (!plan.fundCode || plan.fundCode.length < 6) {
      throw new Error('基金代码格式不正确');
    }

    // 验证净值
    if (plan.currentPrice <= 0) {
      throw new Error('基金净值必须大于0');
    }

    // 验证费率
    if (plan.managementFee < 0 || plan.managementFee > 3) {
      throw new Error('管理费率应在0-3%之间');
    }

    if (plan.subscriptionFee < 0 || plan.subscriptionFee > 2) {
      throw new Error('申购费率应在0-2%之间');
    }

    if (plan.redemptionFee < 0 || plan.redemptionFee > 2) {
      throw new Error('赎回费率应在0-2%之间');
    }
  }

  // 计算基金投资计划的预期份额
  calculateExpectedShares(totalAmount: number, averagePrice: number): number {
    return totalAmount / averagePrice;
  }

  // 计算年化管理费用
  calculateAnnualManagementFee(totalAmount: number, managementFee: number): number {
    return totalAmount * (managementFee / 100);
  }

  // 计算申购费用
  calculateSubscriptionFee(amount: number, subscriptionFee: number): number {
    return amount * (subscriptionFee / 100);
  }

  // 计算赎回费用
  calculateRedemptionFee(amount: number, redemptionFee: number): number {
    return amount * (redemptionFee / 100);
  }

  // 计算实际投资金额（扣除申购费后）
  calculateActualInvestAmount(amount: number, subscriptionFee: number): number {
    return amount - this.calculateSubscriptionFee(amount, subscriptionFee);
  }
}



// 创建默认服务实例 - 使用Supabase
export const fundInvestPlanService = new FundInvestPlanService({
  type: 'supabase',
  supabaseUrl: import.meta.env.VITE_SUPABASE_URL,
  supabaseKey: import.meta.env.VITE_SUPABASE_ANON_KEY
});

// 为了向后兼容，导出原有实例名称
export const investPlanService = fundInvestPlanService;

// 导出服务类，供需要自定义配置的场景使用
export { FundInvestPlanService };